home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / pc / ABUSESRC.ZIP / AbuseSrc / abuse / src / net / mac / socktst.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-04-11  |  7.3 KB  |  344 lines
  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <string.h>
  4. #include "sock.hpp"
  5. #include "tcpip.hpp"
  6.  
  7. #ifdef __POWERPC__
  8. tcpip_protocol tcpip;
  9. #endif
  10.  
  11. char delim[]=" \n";
  12. char spinchar[] = "\\|/-";
  13.  
  14. net_protocol *prot = net_protocol::first;
  15. net_socket::socket_type socktype;
  16. net_address *addr;
  17. int port = 0x9091;
  18. int notify_port = 0x9099;
  19.  
  20. void spin()
  21. //{{{
  22. {
  23.   static int pos = 0;
  24.   
  25.   printf("\r%c",spinchar[pos]);
  26.   pos = (pos+1)&3;
  27. }
  28. //}}}
  29.  
  30. #define MAX_CLIENTS 2
  31.  
  32. void udp_server()
  33. //{{{
  34. {
  35.   net_socket *srv;
  36.   int cont;
  37.  
  38.   // Create listen socket to accept client connections
  39.   printf("Starting server listen socket on port %d.\n",port);
  40.   srv = prot->create_listen_socket(port, socktype);
  41.   srv->read_selectable();
  42.   prot->start_notify(notify_port,"Test server",11);
  43.   printf("Waiting for connections\n");
  44.  
  45.   cont = 1;
  46.   while (cont) {
  47.     spin();
  48.     // wait for next network event
  49.     if (prot->select(0)) {
  50.       if (srv->ready_to_read()) {
  51.         // server socket has data
  52.                 char buf[513];
  53.                 int len;
  54.         net_address *addr;
  55.         char name[80];
  56.  
  57.                 len = srv->read(buf,512,&addr);
  58.                 if (addr)
  59.                     addr->store_string(name,80);
  60.                 else
  61.                     name[0] = 0;
  62.  
  63.                 if (len>0) {
  64.                     buf[len] = 0;
  65.                     printf("Server: Got [%s] from [%s]\n",buf,name);
  66.                 }
  67.  
  68.                 if (addr && len>0) {
  69.                     if (strcmp(buf,"die")==0)
  70.                         cont = 0;
  71.  
  72.                     srv->write(buf,len,addr);
  73.                     printf("Server: Echoing [%s] to [%s]\n",buf,name);
  74.                 }
  75.       }
  76.     }
  77.   }
  78.   delete srv;
  79. }
  80. //}}}
  81.  
  82. void tcp_server()
  83. //{{{
  84. {
  85.   net_socket *srv;
  86.   net_socket *clt[MAX_CLIENTS] = {0,0};
  87.   int state[MAX_CLIENTS] = {0,0};
  88.   char buf[MAX_CLIENTS][256];
  89.   int len[MAX_CLIENTS];
  90.   int cont;
  91.  
  92.   // Create listen socket to accept client connections
  93.   printf("Starting server listen socket.\n");
  94.   srv = prot->create_listen_socket(port, socktype);
  95.   srv->read_selectable();
  96.   prot->start_notify(notify_port,"Test server",11);
  97.   printf("Waiting for connections\n");
  98.  
  99.   cont = 1;
  100.   while (cont) {
  101.     spin();
  102.     // wait for next network event
  103.     if (prot->select(0)) {
  104.       //{{{ Check server socket
  105.       if (srv->ready_to_read()) {
  106.         // server socket has data, i.e. connection requested
  107.         int i;
  108.         net_address *addr;
  109.         net_socket *new_clt;
  110.         char name[80];
  111.       
  112.         new_clt = srv->accept(addr);
  113.         addr->store_string(name,80);
  114.         printf("Got connect from [%s]...",name);
  115.       
  116.         // search for available client storage
  117.         for (i=0; i<MAX_CLIENTS; i++)
  118.           if (clt[i] == 0)
  119.             break;
  120.       
  121.         if (i<MAX_CLIENTS) {
  122.           // save socket to client
  123.           clt[i] = new_clt;
  124.       
  125.           // make reads "selectable" to alert of read events
  126.           new_clt->read_selectable();
  127.           printf("accepted\n");
  128.         }
  129.         else
  130.           printf("rejected!\n");
  131.       }
  132.       //}}}
  133.       //{{{ Check client statuses
  134.       for (int i=0; i<MAX_CLIENTS; i++)
  135.       if (clt[i]) {
  136.         if (clt[i]->error()) {
  137.           printf("Aiieeee!  Error on %d.\n",i);
  138.           delete clt[i];
  139.           clt[i] = 0;
  140.         }
  141.         if (clt[i]->ready_to_read()) {
  142.           // Client sent us data
  143.           if (state[i] == 0) {
  144.             len[i] = clt[i]->read(buf[i], 256);
  145.             if (len[i] <= 0) {
  146.               // 0 length read means EOF
  147.               printf("Closing connection %i\n",i);
  148.               delete clt[i];
  149.               clt[i] = 0;
  150.               break;
  151.             }
  152.             else {
  153.               // normal read
  154.               clt[i]->write_selectable();
  155.               clt[i]->read_unselectable();
  156.               state[i] = 1;
  157.               buf[i][len[i]] = 0;
  158.               printf("Server: From %d Got [%s] len %d\n",i,buf[i],len[i]);
  159.               if (!strcmp(buf[i],"die"))
  160.                 cont = 0;
  161.             }
  162.           }
  163.         }
  164.         if (clt[i]->ready_to_write()) {
  165.           if (state[i] == 1) {
  166.             // Echo data back to client
  167.             clt[i]->write(buf[i], len[i]);
  168.             clt[i]->read_selectable();
  169.             clt[i]->write_unselectable();
  170.             state[i] = 0;
  171.             printf("Server: Echoed to %d: [%s] len %d\n",i,buf[i],len[i]);
  172.           }
  173.         }
  174.       }
  175.       //}}}
  176.     }
  177.   }
  178.   for (int i=0; i<MAX_CLIENTS; i++)
  179.     if (clt[i])
  180.       delete clt[i];
  181.   delete srv;
  182. }
  183. //}}}
  184.  
  185. void client()
  186. //{{{
  187. {
  188.   net_socket *clt;
  189.   char s[256];
  190.   int len, cont;
  191.  
  192.   // finding server
  193.     printf("Trying to find server\n");
  194.     net_address *addr;
  195.   while (!(addr = prot->find_address(notify_port,s)))
  196.         spin();
  197.  
  198.   // Create new socket to server
  199.     addr->set_port(port);
  200.     addr->store_string(s,256);
  201.   printf("Trying to connect to server [%s].\n",s);
  202.     clt = prot->connect_to_server(addr,socktype);
  203.   //  ((unix_fd*)clt)->broadcastable();
  204.   
  205.   while (1) {
  206.     printf("Enter client data.\n");
  207.     gets(s);
  208.  
  209.     // Quit on Q
  210.     if (!strcmp(s,"q"))
  211.       break;
  212.  
  213.     clt->read_unselectable();
  214.     clt->write_selectable();
  215.     while (!clt->ready_to_write() && !clt->error()) {
  216.       spin();
  217.       prot->select(0);
  218.     }
  219.  
  220.     if (clt->error())
  221.       break;
  222.  
  223.     len = clt->write(s,strlen(s));
  224.     
  225.     printf("Wrote [%s] length %d\n",s,len);
  226.     
  227.     clt->read_selectable();
  228.     clt->write_unselectable();
  229.     while (!clt->ready_to_read() && !clt->error()) {
  230.       spin();
  231.       prot->select(0);
  232.     }
  233.     
  234.     if (clt->error())
  235.       break;
  236.     
  237.     len = clt->read(s,256);
  238.  
  239.     if (len <= 0) {
  240.       printf("Server died\n");
  241.       break;
  242.     }
  243.     
  244.     printf("Got [%s] len %d\n",s,len);
  245.   }
  246.   delete clt;
  247. }
  248. //}}}
  249.  
  250. main()
  251. //{{{
  252. {
  253.   char str[256], *s;
  254.  
  255.   if (prot->installed()) {
  256.     printf("Testing %s...\n",prot->name());
  257.   }
  258.   else {
  259.     printf("No protocol!\n");
  260.     exit(1);
  261.   }
  262.  
  263.   while (1) {
  264.     printf("\n> ");
  265.     gets(str);
  266.     s = strtok(str,delim);
  267.     if (!s)
  268.       break;
  269.  
  270.     switch (s[1]) {
  271.     case 'u':
  272.     case 'U':
  273.       socktype = net_socket::SOCKET_FAST;
  274.       break;
  275.     case 's':
  276.     case 'S':
  277.       socktype = net_socket::SOCKET_SECURE;
  278.       break;
  279.     }
  280.  
  281.     switch (s[0]) {
  282.     case 'c':
  283.     case 'C':
  284.       s = strtok(0,delim);
  285. #if 0
  286.       addr = prot->get_node_address(s,port,0);
  287. #else
  288.       sockaddr_in host;
  289.       char tmp[4];
  290.       
  291.       for (int i=0; i<4; i++)
  292.       {
  293.         int num = 0;
  294.         while (*s)
  295.         {
  296.           if (*s=='.')
  297.           {
  298.             s++;
  299.             break;
  300.           }
  301.           num = num*10 + *s - '0';
  302.           s++;
  303.         }
  304.         tmp[i] = num;
  305.       }
  306.       
  307.       memset( (char*) &host,0, sizeof(host));
  308.       host.sin_family = AF_INET;
  309.       host.sin_port = htons(port);
  310.       host.sin_addr.s_addr = htonl(INADDR_ANY);
  311.       memcpy(&host.sin_addr,tmp,sizeof(in_addr));
  312.       
  313.       addr = new ip_address(&host);
  314. #endif
  315.       client();
  316.       break;
  317.     case 's':
  318.     case 'S':
  319.             if (socktype == net_socket::SOCKET_FAST)
  320.                 udp_server();
  321.             else
  322.                 tcp_server();
  323.       break;
  324.     case 'q':
  325.     case 'Q':
  326.       exit(1);
  327.       break;
  328.     }
  329.   }
  330. }
  331. //}}}
  332.  
  333. //{{{ Revision Log
  334. /*//////////////////////////////////////////////////////////////////////
  335. $Log$
  336. //////////////////////////////////////////////////////////////////////*/
  337. //}}}
  338.  
  339. //{{{ Emacs Locals
  340. // Local Variables:
  341. // folded-file: t
  342. // End:
  343. //}}}
  344.